package com.wlz.utils;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.wlz.config.ProjectConfig;
import com.wlz.constants.Constants;
import com.wlz.model.AccessTokenBean;
import com.wlz.model.SimplePhoneBean;
import com.wlz.model.WXACodeBean;
import com.wlz.model.WXAGetCodeBean;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.util.StringUtils;

import javax.crypto.Cipher;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import javax.servlet.http.HttpServletRequest;
import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;
import java.nio.charset.StandardCharsets;
import java.security.spec.AlgorithmParameterSpec;
import java.util.Base64;
import java.util.HashMap;
import java.util.Map;

/**
 * 微信相关的工具类
 *
 * @author ：Administrator
 * @date ：2018/10/18/018 10:19
 */


public class WxUtils {

    @Autowired
    private static ProjectConfig projectConfig;
    private static Logger logger = LoggerFactory.getLogger(WxUtils.class);


    /**
     * 获取openId
     *
     * @param wxCode 微信码
     * @return 用户openid
     */
    public static String getCode(String wxCode, String wxAppId, String wxAppSecret) {
        String openId = "";

        try {
            // 1. 得到访问地址的URL
            URL url = new URL("https://api.weixin.qq.com/sns/jscode2session?appid=" + wxAppId + "&secret=" + wxAppSecret + "&js_code=" + wxCode + "&grant_type=authorization_code");
            // 2. 得到网络访问对象java.net.HttpURLConnection
            HttpURLConnection connection = (HttpURLConnection) url
                    .openConnection();
            /* 3. 设置请求参数（过期时间，输入、输出流、访问方式），以流的形式进行连接 */
            // 设置是否向HttpURLConnection输出
            connection.setDoOutput(false);
            // 设置是否从httpUrlConnection读入
            connection.setDoInput(true);
            // 设置请求方式
            connection.setRequestMethod("GET");
            // 设置是否使用缓存
            connection.setUseCaches(true);
            // 设置此 HttpURLConnection 实例是否应该自动执行 HTTP 重定向
            connection.setInstanceFollowRedirects(true);
            // 设置超时时间
            connection.setConnectTimeout(3000);
            // 连接
            connection.connect();
            // 4. 得到响应状态码的返回值 responseCode
            int code = connection.getResponseCode();
            // 5. 如果返回值正常，数据在网络中是以流的形式得到服务端返回的数据
            StringBuilder msg = new StringBuilder();
            // 正常响应
            if (code == 200) {
                // 从流中读取响应信息
                BufferedReader reader = new BufferedReader(
                        new InputStreamReader(connection.getInputStream()));
                String line;

                // 循环从流中读取
                while ((line = reader.readLine()) != null) {
                    msg.append(line).append("\n");
                }
                // 关闭流
                reader.close();
            }
            // 6. 断开连接，释放资源
            connection.disconnect();

            // 显示响应结果
            openId = msg.toString().split("\"openid\":\"")[1].split("\"}")[0];

//            // opnL15QNOC66InAoOW1VDscbiz5A","unionid":"obv66v1kOdFnjSIDbET0rvWd9flE
//            if (openId != null && openId.contains("unionid")) {
//                openId = openId.substring(0,openId.indexOf("\""));
//            }

            logger.info("该微信的openid和unionId是:" + openId);

        } catch (Exception e) {
            e.printStackTrace();
        }
        return openId;
    }


    /**
     * 获取微信的access_token
     *
     * @param appId  微信的appid
     * @param secret 微信的secret
     * @return 返回微信的access_token
     */
    public static AccessTokenBean getWxAccessToken(String appId, String secret) {
        AccessTokenBean accessTokenBean = new AccessTokenBean();
        StringBuilder accessToken = new StringBuilder();

        try {
            // 1. 得到访问地址的URL
            URL url = new URL("https://api.weixin.qq.com/cgi-bin/token?grant_type=client_credential&appid=" + appId + "&secret=" + secret);
            // 2. 得到网络访问对象java.net.HttpURLConnection
            HttpURLConnection connection = (HttpURLConnection) url
                    .openConnection();
            /* 3. 设置请求参数（过期时间，输入、输出流、访问方式），以流的形式进行连接 */
            // 设置是否向HttpURLConnection输出
            connection.setDoOutput(false);
            // 设置是否从httpUrlConnection读入
            connection.setDoInput(true);
            // 设置请求方式
            connection.setRequestMethod("GET");
            // 设置是否使用缓存
            connection.setUseCaches(true);
            // 设置此 HttpURLConnection 实例是否应该自动执行 HTTP 重定向
            connection.setInstanceFollowRedirects(true);
            // 设置超时时间
            connection.setConnectTimeout(3000);
            // 连接
            connection.connect();
            // 4. 得到响应状态码的返回值 responseCode
            int code = connection.getResponseCode();
            // 5. 如果返回值正常，数据在网络中是以流的形式得到服务端返回的数据
            // 正常响应
            if (code == 200) {
                // 从流中读取响应信息
                BufferedReader reader = new BufferedReader(
                        new InputStreamReader(connection.getInputStream()));
                String line;

                // 循环从流中读取
                while ((line = reader.readLine()) != null) {
                    accessToken.append(line).append("\n");
                }
                // 关闭流
                reader.close();
                logger.info("输出access_token:    " + accessToken);
            }
            // 6. 断开连接，释放资源
            connection.disconnect();

            accessTokenBean = JSON.parseObject(accessToken.toString(), AccessTokenBean.class);


        } catch (Exception e) {
            e.printStackTrace();
        }

        return accessTokenBean;
    }




    /**
     * 获取SessionKey 和 openID  和 unionId
     *
     * @param wxCode      微信编码
     * @param wxappid     微信的appId
     * @param wxappsecret 微信的appSecret
     * @return session和OpenID的 组合
     */
    public static Map<String, Object> getCodeAndSessionKey(String wxCode, String wxappid, String wxappsecret) {
        String sessionKey;
        String openId;
        Map<String, Object> codeAndKeyMap = new HashMap<>(16);

        try {
            // 1. 得到访问地址的URL
            URL url = new URL("https://api.weixin.qq.com/sns/jscode2session?appid=" + wxappid + "&secret=" + wxappsecret + "&js_code=" + wxCode + "&grant_type=authorization_code");
            // 2. 得到网络访问对象java.net.HttpURLConnection
            HttpURLConnection connection = (HttpURLConnection) url
                    .openConnection();
            /* 3. 设置请求参数（过期时间，输入、输出流、访问方式），以流的形式进行连接 */
            // 设置是否向HttpURLConnection输出
            connection.setDoOutput(false);
            // 设置是否从httpUrlConnection读入
            connection.setDoInput(true);
            // 设置请求方式
            connection.setRequestMethod("GET");
            // 设置是否使用缓存
            connection.setUseCaches(true);
            // 设置此 HttpURLConnection 实例是否应该自动执行 HTTP 重定向
            connection.setInstanceFollowRedirects(true);
            // 设置超时时间
            connection.setConnectTimeout(3000);
            // 连接
            connection.connect();
            // 4. 得到响应状态码的返回值 responseCode
            int code = connection.getResponseCode();
            // 5. 如果返回值正常，数据在网络中是以流的形式得到服务端返回的数据
            StringBuilder msg = new StringBuilder();
            // 正常响应
            if (code == 200) {
                // 从流中读取响应信息
                BufferedReader reader = new BufferedReader(
                        new InputStreamReader(connection.getInputStream()));
                String line = null;

                // 循环从流中读取
                while ((line = reader.readLine()) != null) {
                    msg.append(line).append("\n");
                }
                // 关闭流
                reader.close();
            }
            // 6. 断开连接，释放资源
            connection.disconnect();

            openId = msg.toString().split("\"openid\":\"")[1].split("\"}")[0];
            sessionKey = msg.toString().split("\"session_key\":\"")[1];
            sessionKey = sessionKey.split("\",")[0];
            codeAndKeyMap.put("sessionKey", sessionKey);
            if (openId != null && openId.contains("unionid")) {
                String  newOpenId = openId.substring(0,openId.indexOf("\""));
                codeAndKeyMap.put("openId", newOpenId);
            }else {
                codeAndKeyMap.put("openId", openId);
            }
            String unionId = null;
            if (openId != null && openId.contains("unionid")) {
                 unionId = openId.substring(openId.lastIndexOf("\"")+1,openId.length());
            }
            codeAndKeyMap.put("unionId", unionId);

            logger.info("sessionKey:" + codeAndKeyMap.get("sessionKey"));
            logger.info("openId:" + codeAndKeyMap.get("openId"));
            logger.info("unionId:" + codeAndKeyMap.get("unionId"));

        } catch (Exception e) {
            e.printStackTrace();
        }
        return codeAndKeyMap;
    }

    /**
     * 获取SessionKey
     *
     * @param wxCode      微信Code
     * @param wxAppId     appId
     * @param wxAppSecret appSecret
     * @return sessionKey
     */
    private static String getSessionKey(String wxCode, String wxAppId, String wxAppSecret) {
        String sessionKey = null;

        try {
            // 1. 得到访问地址的URL
            URL url = new URL("https://api.weixin.qq.com/sns/jscode2session?appid=" + wxAppId + "&secret=" + wxAppSecret + "&js_code=" + wxCode + "&grant_type=authorization_code");
            // 2. 得到网络访问对象java.net.HttpURLConnection
            HttpURLConnection connection = (HttpURLConnection) url
                    .openConnection();
            /* 3. 设置请求参数（过期时间，输入、输出流、访问方式），以流的形式进行连接 */
            // 设置是否向HttpURLConnection输出
            connection.setDoOutput(false);
            // 设置是否从httpUrlConnection读入
            connection.setDoInput(true);
            // 设置请求方式
            connection.setRequestMethod("GET");
            // 设置是否使用缓存
            connection.setUseCaches(true);
            // 设置此 HttpURLConnection 实例是否应该自动执行 HTTP 重定向
            connection.setInstanceFollowRedirects(true);
            // 设置超时时间
            connection.setConnectTimeout(3000);
            // 连接
            connection.connect();
            // 4. 得到响应状态码的返回值 responseCode
            int code = connection.getResponseCode();
            // 5. 如果返回值正常，数据在网络中是以流的形式得到服务端返回的数据
            StringBuilder msg = new StringBuilder();
            // 正常响应
            if (code == 200) {
                // 从流中读取响应信息
                BufferedReader reader = new BufferedReader(
                        new InputStreamReader(connection.getInputStream()));
                String line;

                // 循环从流中读取
                while ((line = reader.readLine()) != null) {
                    msg.append(line).append("\n");
                }
                // 关闭流
                reader.close();
            }
            // 6. 断开连接，释放资源
            connection.disconnect();

            // 显示响应结果
            sessionKey = msg.toString().split("\"session_key\":\"")[1];
            sessionKey = sessionKey.split("\",")[0];

            logger.info("sessionKey:" + sessionKey);

        } catch (Exception e) {
            e.printStackTrace();
        }
        return sessionKey;
    }

    /**
     * 获取小程序存放的地址
     *
     * @param id      id
     * @param page        小程序码跳转的路径
     * @param accessToken 微信的access_token
     * @param secretId    cos的id
     * @param secretKey   cos的秘钥
     * @param wxaCodePath 小程序存放的地址
     * @return 返回一个固定格式的图片的地址
     */
    public static String getWXACode(String id, String page, String accessToken, String secretId, String secretKey, String wxaCodePath) {
        WXACodeBean wxaCodeBean = new WXACodeBean(id, page, true);
        String wxaCodeUrl = "";

//        将参数转换成JSON格式字符串
        String jsonStr = JSON.toJSONString(wxaCodeBean);


        try {
            // 1. 得到访问地址的URL
            URL url = new URL("https://api.weixin.qq.com/wxa/getwxacodeunlimit?access_token=" + accessToken);
            // 2. 得到网络访问对象java.net.HttpURLConnection
            HttpURLConnection connection = (HttpURLConnection) url
                    .openConnection();
            /* 3. 设置请求参数（过期时间，输入、输出流、访问方式），以流的形式进行连接 */
            // 设置是否向HttpURLConnection输出
//            connection.setDoOutput(false);
            // 设置是否从httpUrlConnection读入
            connection.setDoInput(true);
            connection.setDoOutput(true);

            /* optional request header */
            connection.setRequestProperty("Content-Type", "application/json; charset=UTF-8");

            /* optional request header */
            connection.setRequestProperty("Accept", "application/json");

            // 设置请求方式
            connection.setRequestMethod("POST");
            // 设置是否使用缓存
            connection.setUseCaches(true);
            // 设置此 HttpURLConnection 实例是否应该自动执行 HTTP 重定向
            connection.setInstanceFollowRedirects(true);
            // 设置超时时间
            connection.setConnectTimeout(3000);

            //设置携带的参数
            OutputStream os = connection.getOutputStream();
            BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(os, StandardCharsets.UTF_8));
            writer.write(jsonStr);
            writer.flush();
            writer.close();
            os.close();

            // 连接
            connection.connect();
            // 4. 得到响应状态码的返回值 responseCode
            int code = connection.getResponseCode();
            // 5. 如果返回值正常，数据在网络中是以流的形式得到服务utils端返回的数据
            // 正常响应
            logger.info("code>>"+code);
            if (code == Constants.CODE_INTERNET_SUCCESS) {
                InputStream is = connection.getInputStream();
                is.available();
                wxaCodeUrl = CosUtils.uploadInputStreamChangeToImageToCos(is, id, secretId, secretKey, wxaCodePath);
                if ("".equals(wxaCodeUrl)) {
                    logger.info("二维码上传cos 失败");
                }
            } else {
                logger.error("获取小程序码过程出错,错误码为:" + code);
            }
            // 6. 断开连接，释放资源
            connection.disconnect();

        } catch (Exception e) {
            e.printStackTrace();
            logger.error(e.getMessage());
        }

        return wxaCodeUrl;
    }

    /**
     * 获取小程序存放的地址
     *
     * @param id      id
     * @param page        小程序码跳转的路径
     * @param accessToken 微信的access_token
     * @param secretId    cos的id
     * @param secretKey   cos的秘钥
     * @param wxaCodePath 小程序存放的地址
     * @return 返回一个固定格式的图片的地址
     */
    public static String getWXACode(String id, String openId,String page, String accessToken, String secretId, String secretKey, String wxaCodePath, StringRedisTemplate stringRedisTemplate, String tokenID) {
        String path = page + "?" + id;
        WXAGetCodeBean wxaCodeBean = new WXAGetCodeBean(path,true);
        String wxaCodeUrl = "";
        InputStream is = null;
        BufferedReader bufferedReader = null;
//        将参数转换成JSON格式字符串
        String jsonStr = JSON.toJSONString(wxaCodeBean);
        try {
            // 1. 得到访问地址的URL
//            URL url = new URL("https://api.weixin.qq.com/wxa/getwxacodeunlimit?access_token=" + accessToken);
            URL url = new URL("https://api.weixin.qq.com/wxa/getwxacode?access_token=" + accessToken);
            // 2. 得到网络访问对象java.net.HttpURLConnection
            HttpURLConnection connection = (HttpURLConnection) url
                    .openConnection();
            /* 3. 设置请求参数（过期时间，输入、输出流、访问方式），以流的形式进行连接 */
            // 设置是否向HttpURLConnection输出
            connection.setDoOutput(true);
            // 设置是否从httpUrlConnection读入
            connection.setDoInput(true);

            /* optional request header */
            connection.setRequestProperty("Content-Type", "application/json; charset=UTF-8");

            /* optional request header */
            connection.setRequestProperty("Accept", "application/json");

            // 设置请求方式
            connection.setRequestMethod("POST");
            // 设置是否使用缓存
            connection.setUseCaches(true);
            // 设置此 HttpURLConnection 实例是否应该自动执行 HTTP 重定向
            connection.setInstanceFollowRedirects(true);
            // 设置超时时间
            connection.setConnectTimeout(3000);

            //设置携带的参数
            OutputStream os = connection.getOutputStream();
            BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(os, StandardCharsets.UTF_8));
            writer.write(jsonStr);
            writer.flush();
            writer.close();
            os.close();

            // 连接
            connection.connect();

            is = connection.getInputStream();  // 得到图片的二进制内容
            int len = is.available();  // 获取二进制流的长度，该方法不准确
            if(len < 1000){  // 出现错误时，获取字符长度就一百不到，图片的话有几万的长度
                // 定义BufferedReader输入流来读取URL的响应
                bufferedReader = new BufferedReader(new InputStreamReader(connection.getInputStream(), "UTF-8"));
                String line;
                String result = "";
                while ((line = bufferedReader.readLine()) != null) {
                    result += line;
                }
                logger.debug("获取access_token出错："+result);
                // 清空 access_token 缓存
                String key = Constants.REDIS_WXACCESS_TOKEN + tokenID + "_";
                stringRedisTemplate.delete(key);
                return "";
            }

            // 4. 得到响应状态码的返回值 responseCode
            int code = connection.getResponseCode();
            // 5. 如果返回值正常，数据在网络中是以流的形式得到服务utils端返回的数据
            // 正常响应
            logger.info("code>>"+code);
            if (code == Constants.CODE_INTERNET_SUCCESS) {
                wxaCodeUrl = CosUtils.uploadInputStreamChangeToImageToCos(is, openId, secretId, secretKey, wxaCodePath);
                if ("".equals(wxaCodeUrl)) {
                    logger.info("二维码上传cos 失败");
                }
            } else {
                logger.error("获取小程序码过程出错,错误码为:" + code);
            }
            // 6. 断开连接，释放资源
            connection.disconnect();

        } catch (Exception e) {
            e.printStackTrace();
            logger.error(e.getMessage());
        }

        return wxaCodeUrl;
    }






    public static String getWXQrcode(String access_token, String page, String scene, Integer width,String secretId, String secretKey, String wxaCodePath) {
        String qrcodeUrl = "https://api.weixin.qq.com/wxa/getwxacodeunlimit";  // 获取小程序码的接口头部
        String url = qrcodeUrl+"?access_token="+access_token;  // 拼接完整的URl
        Map<String, Object> requestParam = new HashMap<String,Object>();  // 小程序的参数可查看官方文档
        if(page!= null) requestParam.put("page", page);  // 扫码后需要跳转的页面
        if(scene!= null) requestParam.put("scene", scene);  // 携带的参数
        if(width!= null) requestParam.put("width", width);  // 二维码的宽度
        requestParam.put("is_hyaline",true);
        String param = JSON.toJSONString(requestParam);

        // 使用 RestTemplate 出现的问题，用该类代码会更简洁
        // rest debugger发过来的content-type为application/json，而jq的多了charset=utf-8
        // Could not read document: Invalid UTF-8 middle byte 0xff
        /*JSONObject jsonObject =
			restTemplate.postForObject(url, param, JSONObject.class);
	    System.out.println(jsonObject.toJSONString());*/

        HttpURLConnection conn = null;
        BufferedReader bufferedReader = null;
        PrintWriter out = null;
        InputStream in = null;
        ByteArrayOutputStream bos = null;
        String base64String = "";
        try {
            URL realUrl = new URL(url);
            // 打开和URL之间的连接
            conn = (HttpURLConnection) realUrl.openConnection();
            // 设置通用的请求属性
            conn.setRequestProperty("accept", "*/*");
            conn.setRequestProperty("connection", "Keep-Alive");
            conn.setRequestProperty("Accept-Charset", "UTF-8");
            conn.setRequestProperty("user-agent", "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1;SV1)");
            // 超时设置,防止 网络异常的情况下,可能会导致程序僵死而不继续往下执行
            conn.setConnectTimeout(3000);
            conn.setReadTimeout(3000);
            // 发送POST请求必须设置如下两行
            conn.setDoOutput(true);
            conn.setDoInput(true);
            // 获取URLConnection对象对应的输出流
            out = new PrintWriter(conn.getOutputStream());
            // 发送请求参数
            out.print(param);
            // flush输出流的缓冲
            out.flush();

            in = conn.getInputStream();  // 得到图片的二进制内容
            int leng = in.available();  // 获取二进制流的长度，该方法不准确
            if(leng < 1000){  // 出现错误时，获取字符长度就一百不到，图片的话有几万的长度
                // 定义BufferedReader输入流来读取URL的响应
                bufferedReader = new BufferedReader(new InputStreamReader(conn.getInputStream(), "UTF-8"));
                String line;
                String result = "";
                while ((line = bufferedReader.readLine()) != null) {
                    result += line;
                }
                logger.debug("获取access_token出错："+result);
                // 清空 access_token 缓存
//                CacheManagerImpl cacheManagerImpl = CacheManagerImpl.getInstance();
//                cacheManagerImpl.clearByKey("access_token");
                return result;
            }
            int code = conn.getResponseCode();
            // 5. 如果返回值正常，数据在网络中是以流的形式得到服务utils端返回的数据
            // 正常响应
            logger.info("code>>"+code);
            if (code == Constants.CODE_INTERNET_SUCCESS) {
                base64String = CosUtils.uploadInputStreamChangeToImageToCos(in, scene, secretId, secretKey, wxaCodePath);
                if ("".equals(base64String)) {
                    logger.info("二维码上传cos 失败");
                }
            } else {
                logger.error("获取小程序码过程出错,错误码为:" + code);
            }


        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        }
        //使用finally块来关闭输出流、输入流
        finally{
            try {
                if(bufferedReader != null){
                    bufferedReader.close();
                }
                if(out!=null){
                    out.close();
                }
                if(in!=null){
                    in.close();
                }
                if(bos != null){
                    bos.close();
                }
                if(conn !=null){
                    conn.disconnect();
                    conn = null;
                }
                //让系统回收资源，但不一定是回收刚才设成null的资源，可能是回收其他没用的资源。
                System.gc();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        return base64String;  // 将base64格式的图片发送到前端
    }

    public static Map<String, Object> getUserPhone(String encryptedData, String iv, String wxappsecret, String wxappid, String wxCode, HttpServletRequest request) {

        Map<String, Object> objectMap = new HashMap<>(16);
        String phone = "";
        try {
            if (!StringUtils.isEmpty(wxCode)) {
                objectMap = getCodeAndSessionKey(wxCode, wxappid, wxappsecret);
            }

//            phone = (encryptedData, String.valueOf(objectMap.get("sessionKey")), iv);
            phone = wxDecrypt(encryptedData, String.valueOf(objectMap.get("sessionKey")), iv);

            if (StringUtils.isEmpty(phone)) {
                phone = getPhoneDecrypt(encryptedData, String.valueOf(objectMap.get("sessionKey")), iv);
//                phone = wxDecrypt(encryptedData, String.valueOf(objectMap.get("sessionKey")), iv);
            }
            objectMap.put("phone", phone);
        } catch (Exception e) {
            logger.error("getUserPhone:",e);
        }
        logger.info("获取到的手机号码为:"+phone);
        return objectMap;
    }

    private static String getPhoneDecrypt(String encryptedData, String sessionKey,String iv) {
        String phoneNumber = null;
        String result = null;
        try {
            result = WechatDecryptDataUtil.decryptData(encryptedData, sessionKey, iv);
            logger.info("result:"+result);
            SimplePhoneBean phoneBean = JSONObject.parseObject(result, SimplePhoneBean.class);
            if (null != phoneBean) {
                phoneNumber = phoneBean.getPhoneNumber();
            }
            logger.info("PhoneNumber====="+phoneNumber);
        } catch (Exception e) {
            logger.error("getPhoneDecrypt",e);
        }
        return phoneNumber;
    }

    private static String wxDecrypt(String encrypted, String sessionKey, String iv) throws Exception {
        String decrypt = null;
        try {
            byte[] encryptData = Base64.getMimeDecoder().decode(encrypted);
            byte[] ivData = Base64.getMimeDecoder().decode(iv);
            byte[] sKey = Base64.getMimeDecoder().decode(sessionKey);
            decrypt = decrypt(sKey, ivData, encryptData);
        } catch (Exception e) {
            logger.error("wxDecrypt:",e);
        }
        return decrypt;

    }

    private static String decrypt(byte[] key, byte[] iv, byte[] encData) throws Exception {
        AlgorithmParameterSpec ivSpec = new IvParameterSpec(iv);
        SecretKeySpec keySpec = new SecretKeySpec(key, "AES");
        String phoneNumber = null;
        try {
            Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
            cipher.init(Cipher.DECRYPT_MODE, keySpec, ivSpec);
            //解析解密后的字符串
            String msg = new String(cipher.doFinal(encData), StandardCharsets.UTF_8);
            SimplePhoneBean phoneBean = JSONObject.parseObject(msg, SimplePhoneBean.class);
            if (null != phoneBean) {
                phoneNumber = phoneBean.getPhoneNumber();
            }
            logger.info("PhoneNumber====="+phoneNumber);
        } catch (Exception e) {
            logger.error("decrypt:",e);
        }
        return phoneNumber;
    }
}
